home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / PIL / Image.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  32.0 KB  |  1,288 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. VERSION = '1.1.6'
  5.  
  6. try:
  7.     import warnings
  8. except ImportError:
  9.     warnings = None
  10.  
  11.  
  12. class _imaging_not_installed:
  13.     
  14.     def __getattr__(self, id):
  15.         raise ImportError('The _imaging C module is not installed')
  16.  
  17.  
  18.  
  19. try:
  20.     __import__('FixTk')
  21. except ImportError:
  22.     pass
  23.  
  24.  
  25. try:
  26.     import _imaging
  27.     core = _imaging
  28.     del _imaging
  29. except ImportError:
  30.     v = None
  31.     core = _imaging_not_installed()
  32.     if str(v)[:20] == 'Module use of python' and warnings:
  33.         warnings.warn('The _imaging extension was built for another version of Python; most PIL functions will be disabled', RuntimeWarning)
  34.     
  35. except:
  36.     warnings
  37.  
  38. import ImageMode
  39. import ImagePalette
  40. import os
  41. import string
  42. import sys
  43. from types import IntType, StringType, TupleType
  44.  
  45. try:
  46.     UnicodeStringType = type(unicode(''))
  47.     
  48.     def isStringType(t):
  49.         if not isinstance(t, StringType):
  50.             pass
  51.         return isinstance(t, UnicodeStringType)
  52.  
  53. except NameError:
  54.     
  55.     def isStringType(t):
  56.         return isinstance(t, StringType)
  57.  
  58.  
  59.  
  60. def isTupleType(t):
  61.     return isinstance(t, TupleType)
  62.  
  63.  
  64. def isImageType(t):
  65.     return hasattr(t, 'im')
  66.  
  67.  
  68. def isDirectory(f):
  69.     if isStringType(f):
  70.         pass
  71.     return os.path.isdir(f)
  72.  
  73. from operator import isNumberType, isSequenceType
  74. DEBUG = 0
  75. NONE = 0
  76. FLIP_LEFT_RIGHT = 0
  77. FLIP_TOP_BOTTOM = 1
  78. ROTATE_90 = 2
  79. ROTATE_180 = 3
  80. ROTATE_270 = 4
  81. AFFINE = 0
  82. EXTENT = 1
  83. PERSPECTIVE = 2
  84. QUAD = 3
  85. MESH = 4
  86. NONE = 0
  87. NEAREST = 0
  88. ANTIALIAS = 1
  89. LINEAR = BILINEAR = 2
  90. CUBIC = BICUBIC = 3
  91. NONE = 0
  92. NEAREST = 0
  93. ORDERED = 1
  94. RASTERIZE = 2
  95. FLOYDSTEINBERG = 3
  96. WEB = 0
  97. ADAPTIVE = 1
  98. NORMAL = 0
  99. SEQUENCE = 1
  100. CONTAINER = 2
  101. ID = []
  102. OPEN = { }
  103. MIME = { }
  104. SAVE = { }
  105. EXTENSION = { }
  106. _MODEINFO = {
  107.     '1': ('L', 'L', ('1',)),
  108.     'L': ('L', 'L', ('L',)),
  109.     'I': ('L', 'I', ('I',)),
  110.     'F': ('L', 'F', ('F',)),
  111.     'P': ('RGB', 'L', ('P',)),
  112.     'RGB': ('RGB', 'L', ('R', 'G', 'B')),
  113.     'RGBX': ('RGB', 'L', ('R', 'G', 'B', 'X')),
  114.     'RGBA': ('RGB', 'L', ('R', 'G', 'B', 'A')),
  115.     'CMYK': ('RGB', 'L', ('C', 'M', 'Y', 'K')),
  116.     'YCbCr': ('RGB', 'L', ('Y', 'Cb', 'Cr')) }
  117. if sys.byteorder == 'little':
  118.     _ENDIAN = '<'
  119. else:
  120.     _ENDIAN = '>'
  121. _MODE_CONV = {
  122.     '1': ('|b1', None),
  123.     'L': ('|u1', None),
  124.     'I': ('%si4' % _ENDIAN, None),
  125.     'F': ('%sf4' % _ENDIAN, None),
  126.     'P': ('|u1', None),
  127.     'RGB': ('|u1', 3),
  128.     'RGBX': ('|u1', 4),
  129.     'RGBA': ('|u1', 4),
  130.     'CMYK': ('|u1', 4),
  131.     'YCbCr': ('|u1', 4) }
  132.  
  133. def _conv_type_shape(im):
  134.     shape = im.size[::-1]
  135.     (typ, extra) = _MODE_CONV[im.mode]
  136.     if extra is None:
  137.         return (shape, typ)
  138.     else:
  139.         return (shape + (extra,), typ)
  140.  
  141. MODES = _MODEINFO.keys()
  142. MODES.sort()
  143. _MAPMODES = ('L', 'P', 'RGBX', 'RGBA', 'CMYK', 'I;16', 'I;16B')
  144.  
  145. def getmodebase(mode):
  146.     return ImageMode.getmode(mode).basemode
  147.  
  148.  
  149. def getmodetype(mode):
  150.     return ImageMode.getmode(mode).basetype
  151.  
  152.  
  153. def getmodebandnames(mode):
  154.     return ImageMode.getmode(mode).bands
  155.  
  156.  
  157. def getmodebands(mode):
  158.     return len(ImageMode.getmode(mode).bands)
  159.  
  160. _initialized = 0
  161.  
  162. def preinit():
  163.     global _initialized
  164.     if _initialized >= 1:
  165.         return None
  166.     
  167.     
  168.     try:
  169.         import BmpImagePlugin
  170.     except ImportError:
  171.         pass
  172.  
  173.     
  174.     try:
  175.         import GifImagePlugin
  176.     except ImportError:
  177.         pass
  178.  
  179.     
  180.     try:
  181.         import JpegImagePlugin
  182.     except ImportError:
  183.         pass
  184.  
  185.     
  186.     try:
  187.         import PpmImagePlugin
  188.     except ImportError:
  189.         pass
  190.  
  191.     
  192.     try:
  193.         import PngImagePlugin
  194.     except ImportError:
  195.         pass
  196.  
  197.     _initialized = 1
  198.  
  199.  
  200. def init():
  201.     global _initialized
  202.     if _initialized >= 2:
  203.         return None
  204.     
  205.     visited = { }
  206.     directories = sys.path
  207.     
  208.     try:
  209.         directories = directories + [
  210.             os.path.dirname(__file__)]
  211.     except NameError:
  212.         pass
  213.  
  214.     for directory in filter(isDirectory, directories):
  215.         fullpath = os.path.abspath(directory)
  216.         if visited.has_key(fullpath):
  217.             continue
  218.         
  219.         for file in os.listdir(directory):
  220.             if file[-14:] == 'ImagePlugin.py':
  221.                 (f, e) = os.path.splitext(file)
  222.                 
  223.                 try:
  224.                     sys.path.insert(0, directory)
  225.                     
  226.                     try:
  227.                         __import__(f, globals(), locals(), [])
  228.                     finally:
  229.                         del sys.path[0]
  230.  
  231.                 except ImportError:
  232.                     if DEBUG:
  233.                         print 'Image: failed to import', f, ':', sys.exc_value
  234.                     
  235.                 except:
  236.                     DEBUG
  237.                 
  238.  
  239.             None<EXCEPTION MATCH>ImportError
  240.         
  241.         visited[fullpath] = None
  242.     
  243.     if OPEN or SAVE:
  244.         _initialized = 2
  245.     
  246.  
  247.  
  248. def _getdecoder(mode, decoder_name, args, extra = ()):
  249.     if args is None:
  250.         args = ()
  251.     elif not isTupleType(args):
  252.         args = (args,)
  253.     
  254.     
  255.     try:
  256.         decoder = getattr(core, decoder_name + '_decoder')
  257.         return apply(decoder, (mode,) + args + extra)
  258.     except AttributeError:
  259.         raise IOError('decoder %s not available' % decoder_name)
  260.  
  261.  
  262.  
  263. def _getencoder(mode, encoder_name, args, extra = ()):
  264.     if args is None:
  265.         args = ()
  266.     elif not isTupleType(args):
  267.         args = (args,)
  268.     
  269.     
  270.     try:
  271.         encoder = getattr(core, encoder_name + '_encoder')
  272.         return apply(encoder, (mode,) + args + extra)
  273.     except AttributeError:
  274.         raise IOError('encoder %s not available' % encoder_name)
  275.  
  276.  
  277.  
  278. class _E:
  279.     
  280.     def __init__(self, data):
  281.         self.data = data
  282.  
  283.     
  284.     def __coerce__(self, other):
  285.         return (self, _E(other))
  286.  
  287.     
  288.     def __add__(self, other):
  289.         return _E((self.data, '__add__', other.data))
  290.  
  291.     
  292.     def __mul__(self, other):
  293.         return _E((self.data, '__mul__', other.data))
  294.  
  295.  
  296.  
  297. def _getscaleoffset(expr):
  298.     stub = [
  299.         'stub']
  300.     data = expr(_E(stub)).data
  301.     
  302.     try:
  303.         (a, b, c) = data
  304.         if a is stub and b == '__mul__' and isNumberType(c):
  305.             return (c, 0)
  306.         
  307.         if a is stub and b == '__add__' and isNumberType(c):
  308.             return (1, c)
  309.     except TypeError:
  310.         pass
  311.  
  312.     
  313.     try:
  314.         (a, b, c) = ()
  315.         d = data
  316.         e = None
  317.         if a is stub and b == '__mul__' and isNumberType(c) and d == '__add__' and isNumberType(e):
  318.             return (c, e)
  319.     except TypeError:
  320.         pass
  321.  
  322.     raise ValueError('illegal expression')
  323.  
  324.  
  325. class Image:
  326.     format = None
  327.     format_description = None
  328.     
  329.     def __init__(self):
  330.         self.im = None
  331.         self.mode = ''
  332.         self.size = (0, 0)
  333.         self.palette = None
  334.         self.info = { }
  335.         self.category = NORMAL
  336.         self.readonly = 0
  337.  
  338.     
  339.     def _new(self, im):
  340.         new = Image()
  341.         new.im = im
  342.         new.mode = im.mode
  343.         new.size = im.size
  344.         new.palette = self.palette
  345.         if im.mode == 'P':
  346.             new.palette = ImagePalette.ImagePalette()
  347.         
  348.         
  349.         try:
  350.             new.info = self.info.copy()
  351.         except AttributeError:
  352.             new.info = { }
  353.             for k, v in self.info:
  354.                 new.info[k] = v
  355.             
  356.  
  357.         return new
  358.  
  359.     _makeself = _new
  360.     
  361.     def _copy(self):
  362.         self.load()
  363.         self.im = self.im.copy()
  364.         self.readonly = 0
  365.  
  366.     
  367.     def _dump(self, file = None, format = None):
  368.         import tempfile
  369.         if not file:
  370.             file = tempfile.mktemp()
  371.         
  372.         self.load()
  373.         if not format or format == 'PPM':
  374.             self.im.save_ppm(file)
  375.         else:
  376.             file = file + '.' + format
  377.             self.save(file, format)
  378.         return file
  379.  
  380.     
  381.     def __getattr__(self, name):
  382.         if name == '__array_interface__':
  383.             new = { }
  384.             (shape, typestr) = _conv_type_shape(self)
  385.             new['shape'] = shape
  386.             new['typestr'] = typestr
  387.             new['data'] = self.tostring()
  388.             return new
  389.         
  390.         raise AttributeError(name)
  391.  
  392.     
  393.     def tostring(self, encoder_name = 'raw', *args):
  394.         if len(args) == 1 and isTupleType(args[0]):
  395.             args = args[0]
  396.         
  397.         if encoder_name == 'raw' and args == ():
  398.             args = self.mode
  399.         
  400.         self.load()
  401.         e = _getencoder(self.mode, encoder_name, args)
  402.         e.setimage(self.im)
  403.         bufsize = max(65536, self.size[0] * 4)
  404.         data = []
  405.         while None:
  406.             (l, s, d) = e.encode(bufsize)
  407.             if s:
  408.                 break
  409.                 continue
  410.             continue
  411.             if s < 0:
  412.                 raise RuntimeError('encoder error %d in tostring' % s)
  413.             
  414.         return string.join(data, '')
  415.  
  416.     
  417.     def tobitmap(self, name = 'image'):
  418.         self.load()
  419.         if self.mode != '1':
  420.             raise ValueError('not a bitmap')
  421.         
  422.         data = self.tostring('xbm')
  423.         return string.join([
  424.             '#define %s_width %d\n' % (name, self.size[0]),
  425.             '#define %s_height %d\n' % (name, self.size[1]),
  426.             'static char %s_bits[] = {\n' % name,
  427.             data,
  428.             '};'], '')
  429.  
  430.     
  431.     def fromstring(self, data, decoder_name = 'raw', *args):
  432.         if len(args) == 1 and isTupleType(args[0]):
  433.             args = args[0]
  434.         
  435.         if decoder_name == 'raw' and args == ():
  436.             args = self.mode
  437.         
  438.         d = _getdecoder(self.mode, decoder_name, args)
  439.         d.setimage(self.im)
  440.         s = d.decode(data)
  441.         if s[0] >= 0:
  442.             raise ValueError('not enough image data')
  443.         
  444.         if s[1] != 0:
  445.             raise ValueError('cannot decode image data')
  446.         
  447.  
  448.     
  449.     def load(self):
  450.         if self.im and self.palette and self.palette.dirty:
  451.             apply(self.im.putpalette, self.palette.getdata())
  452.             self.palette.dirty = 0
  453.             self.palette.mode = 'RGB'
  454.             self.palette.rawmode = None
  455.             if self.info.has_key('transparency'):
  456.                 self.im.putpalettealpha(self.info['transparency'], 0)
  457.                 self.palette.mode = 'RGBA'
  458.             
  459.         
  460.         if self.im:
  461.             return self.im.pixel_access(self.readonly)
  462.         
  463.  
  464.     
  465.     def verify(self):
  466.         pass
  467.  
  468.     
  469.     def convert(self, mode = None, data = None, dither = None, palette = WEB, colors = 256):
  470.         if not mode:
  471.             if self.mode == 'P':
  472.                 self.load()
  473.                 if self.palette:
  474.                     mode = self.palette.mode
  475.                 else:
  476.                     mode = 'RGB'
  477.             else:
  478.                 return self.copy()
  479.         
  480.         self.load()
  481.         if data:
  482.             if mode not in ('L', 'RGB'):
  483.                 raise ValueError('illegal conversion')
  484.             
  485.             im = self.im.convert_matrix(mode, data)
  486.             return self._new(im)
  487.         
  488.         if mode == 'P' and palette == ADAPTIVE:
  489.             im = self.im.quantize(colors)
  490.             return self._new(im)
  491.         
  492.         if dither is None:
  493.             dither = FLOYDSTEINBERG
  494.         
  495.         
  496.         try:
  497.             im = self.im.convert(mode, dither)
  498.         except ValueError:
  499.             
  500.             try:
  501.                 im = self.im.convert(getmodebase(self.mode))
  502.                 im = im.convert(mode, dither)
  503.             except KeyError:
  504.                 raise ValueError('illegal conversion')
  505.             except:
  506.                 None<EXCEPTION MATCH>KeyError
  507.             
  508.  
  509.             None<EXCEPTION MATCH>KeyError
  510.  
  511.         return self._new(im)
  512.  
  513.     
  514.     def quantize(self, colors = 256, method = 0, kmeans = 0, palette = None):
  515.         self.load()
  516.         if palette:
  517.             palette.load()
  518.             if palette.mode != 'P':
  519.                 raise ValueError('bad mode for palette image')
  520.             
  521.             if self.mode != 'RGB' and self.mode != 'L':
  522.                 raise ValueError('only RGB or L mode images can be quantized to a palette')
  523.             
  524.             im = self.im.convert('P', 1, palette.im)
  525.             return self._makeself(im)
  526.         
  527.         im = self.im.quantize(colors, method, kmeans)
  528.         return self._new(im)
  529.  
  530.     
  531.     def copy(self):
  532.         self.load()
  533.         im = self.im.copy()
  534.         return self._new(im)
  535.  
  536.     
  537.     def crop(self, box = None):
  538.         self.load()
  539.         if box is None:
  540.             return self.copy()
  541.         
  542.         return _ImageCrop(self, box)
  543.  
  544.     
  545.     def draft(self, mode, size):
  546.         pass
  547.  
  548.     
  549.     def _expand(self, xmargin, ymargin = None):
  550.         if ymargin is None:
  551.             ymargin = xmargin
  552.         
  553.         self.load()
  554.         return self._new(self.im.expand(xmargin, ymargin, 0))
  555.  
  556.     
  557.     def filter(self, filter):
  558.         self.load()
  559.         Filter = Filter
  560.         import ImageFilter
  561.         if not isinstance(filter, Filter):
  562.             filter = filter()
  563.         
  564.         if self.im.bands == 1:
  565.             return self._new(filter.filter(self.im))
  566.         
  567.         ims = []
  568.         for c in range(self.im.bands):
  569.             ims.append(self._new(filter.filter(self.im.getband(c))))
  570.         
  571.         return merge(self.mode, ims)
  572.  
  573.     
  574.     def getbands(self):
  575.         return ImageMode.getmode(self.mode).bands
  576.  
  577.     
  578.     def getbbox(self):
  579.         self.load()
  580.         return self.im.getbbox()
  581.  
  582.     
  583.     def getcolors(self, maxcolors = 256):
  584.         self.load()
  585.         if self.mode in ('1', 'L', 'P'):
  586.             h = self.im.histogram()
  587.             out = []
  588.             for i in range(256):
  589.                 if h[i]:
  590.                     out.append((h[i], i))
  591.                     continue
  592.             
  593.             if len(out) > maxcolors:
  594.                 return None
  595.             
  596.             return out
  597.         
  598.         return self.im.getcolors(maxcolors)
  599.  
  600.     
  601.     def getdata(self, band = None):
  602.         self.load()
  603.         if band is not None:
  604.             return self.im.getband(band)
  605.         
  606.         return self.im
  607.  
  608.     
  609.     def getextrema(self):
  610.         self.load()
  611.         if self.im.bands > 1:
  612.             extrema = []
  613.             for i in range(self.im.bands):
  614.                 extrema.append(self.im.getband(i).getextrema())
  615.             
  616.             return tuple(extrema)
  617.         
  618.         return self.im.getextrema()
  619.  
  620.     
  621.     def getim(self):
  622.         self.load()
  623.         return self.im.ptr
  624.  
  625.     
  626.     def getpalette(self):
  627.         self.load()
  628.         
  629.         try:
  630.             return map(ord, self.im.getpalette())
  631.         except ValueError:
  632.             return None
  633.  
  634.  
  635.     
  636.     def getpixel(self, xy):
  637.         self.load()
  638.         return self.im.getpixel(xy)
  639.  
  640.     
  641.     def getprojection(self):
  642.         self.load()
  643.         (x, y) = self.im.getprojection()
  644.         return (map(ord, x), map(ord, y))
  645.  
  646.     
  647.     def histogram(self, mask = None, extrema = None):
  648.         self.load()
  649.         if mask:
  650.             mask.load()
  651.             return self.im.histogram((0, 0), mask.im)
  652.         
  653.         if self.mode in ('I', 'F'):
  654.             if extrema is None:
  655.                 extrema = self.getextrema()
  656.             
  657.             return self.im.histogram(extrema)
  658.         
  659.         return self.im.histogram()
  660.  
  661.     
  662.     def offset(self, xoffset, yoffset = None):
  663.         if warnings:
  664.             warnings.warn("'offset' is deprecated; use 'ImageChops.offset' instead", DeprecationWarning, stacklevel = 2)
  665.         
  666.         import ImageChops
  667.         return ImageChops.offset(self, xoffset, yoffset)
  668.  
  669.     
  670.     def paste(self, im, box = None, mask = None):
  671.         if isImageType(box) and mask is None:
  672.             mask = box
  673.             box = None
  674.         
  675.         if box is None:
  676.             box = (0, 0) + self.size
  677.         
  678.         if len(box) == 2:
  679.             if isImageType(im):
  680.                 size = im.size
  681.             elif isImageType(mask):
  682.                 size = mask.size
  683.             else:
  684.                 raise ValueError('cannot determine region size; use 4-item box')
  685.             box = box + (box[0] + size[0], box[1] + size[1])
  686.         
  687.         if isStringType(im):
  688.             import ImageColor
  689.             im = ImageColor.getcolor(im, self.mode)
  690.         elif isImageType(im):
  691.             im.load()
  692.             if self.mode != im.mode:
  693.                 if self.mode != 'RGB' or im.mode not in ('RGBA', 'RGBa'):
  694.                     im = im.convert(self.mode)
  695.                 
  696.             
  697.             im = im.im
  698.         
  699.         self.load()
  700.         if self.readonly:
  701.             self._copy()
  702.         
  703.         if mask:
  704.             mask.load()
  705.             self.im.paste(im, box, mask.im)
  706.         else:
  707.             self.im.paste(im, box)
  708.  
  709.     
  710.     def point(self, lut, mode = None):
  711.         self.load()
  712.         if not isSequenceType(lut):
  713.             if self.mode in ('I', 'I;16', 'F'):
  714.                 (scale, offset) = _getscaleoffset(lut)
  715.                 return self._new(self.im.point_transform(scale, offset))
  716.             
  717.             lut = map(lut, range(256)) * self.im.bands
  718.         
  719.         if self.mode == 'F':
  720.             raise ValueError('point operation not supported for this mode')
  721.         
  722.         return self._new(self.im.point(lut, mode))
  723.  
  724.     
  725.     def putalpha(self, alpha):
  726.         self.load()
  727.         if self.readonly:
  728.             self._copy()
  729.         
  730.         if self.mode not in ('LA', 'RGBA'):
  731.             
  732.             try:
  733.                 mode = getmodebase(self.mode) + 'A'
  734.                 
  735.                 try:
  736.                     self.im.setmode(mode)
  737.                 except (AttributeError, ValueError):
  738.                     im = self.im.convert(mode)
  739.                     if im.mode not in ('LA', 'RGBA'):
  740.                         raise ValueError
  741.                     
  742.                     self.im = im
  743.  
  744.                 self.mode = self.im.mode
  745.             except (KeyError, ValueError):
  746.                 raise ValueError('illegal image mode')
  747.             except:
  748.                 None<EXCEPTION MATCH>(KeyError, ValueError)
  749.             
  750.  
  751.         None<EXCEPTION MATCH>(KeyError, ValueError)
  752.         if self.mode == 'LA':
  753.             band = 1
  754.         else:
  755.             band = 3
  756.         if isImageType(alpha):
  757.             if alpha.mode not in ('1', 'L'):
  758.                 raise ValueError('illegal image mode')
  759.             
  760.             alpha.load()
  761.             if alpha.mode == '1':
  762.                 alpha = alpha.convert('L')
  763.             
  764.         else:
  765.             
  766.             try:
  767.                 self.im.fillband(band, alpha)
  768.             except (AttributeError, ValueError):
  769.                 alpha = new('L', self.size, alpha)
  770.  
  771.             return None
  772.         self.im.putband(alpha.im, band)
  773.  
  774.     
  775.     def putdata(self, data, scale = 1, offset = 0):
  776.         self.load()
  777.         if self.readonly:
  778.             self._copy()
  779.         
  780.         self.im.putdata(data, scale, offset)
  781.  
  782.     
  783.     def putpalette(self, data, rawmode = 'RGB'):
  784.         self.load()
  785.         if self.mode not in ('L', 'P'):
  786.             raise ValueError('illegal image mode')
  787.         
  788.         if not isStringType(data):
  789.             data = string.join(map(chr, data), '')
  790.         
  791.         self.mode = 'P'
  792.         self.palette = ImagePalette.raw(rawmode, data)
  793.         self.palette.mode = 'RGB'
  794.         self.load()
  795.  
  796.     
  797.     def putpixel(self, xy, value):
  798.         self.load()
  799.         if self.readonly:
  800.             self._copy()
  801.         
  802.         return self.im.putpixel(xy, value)
  803.  
  804.     
  805.     def resize(self, size, resample = NEAREST):
  806.         if resample not in (NEAREST, BILINEAR, BICUBIC, ANTIALIAS):
  807.             raise ValueError('unknown resampling filter')
  808.         
  809.         self.load()
  810.         if self.mode in ('1', 'P'):
  811.             resample = NEAREST
  812.         
  813.         if resample == ANTIALIAS:
  814.             
  815.             try:
  816.                 im = self.im.stretch(size, resample)
  817.             except AttributeError:
  818.                 raise ValueError('unsupported resampling filter')
  819.             except:
  820.                 None<EXCEPTION MATCH>AttributeError
  821.             
  822.  
  823.         None<EXCEPTION MATCH>AttributeError
  824.         im = self.im.resize(size, resample)
  825.         return self._new(im)
  826.  
  827.     
  828.     def rotate(self, angle, resample = NEAREST, expand = 0):
  829.         if expand:
  830.             import math
  831.             angle = -angle * math.pi / 180
  832.             matrix = [
  833.                 math.cos(angle),
  834.                 math.sin(angle),
  835.                 0,
  836.                 -math.sin(angle),
  837.                 math.cos(angle),
  838.                 0]
  839.             
  840.             def transform(x, y, .2 = matrix):
  841.                 (a, b, c, d, e, f) = .2
  842.                 return (a * x + b * y + c, d * x + e * y + f)
  843.  
  844.             (w, h) = self.size
  845.             xx = []
  846.             yy = []
  847.             for x, y in ((0, 0), (w, 0), (w, h), (0, h)):
  848.                 (x, y) = transform(x, y)
  849.                 xx.append(x)
  850.                 yy.append(y)
  851.             
  852.             w = int(math.ceil(max(xx)) - math.floor(min(xx)))
  853.             h = int(math.ceil(max(yy)) - math.floor(min(yy)))
  854.             (x, y) = transform(w / 2, h / 2)
  855.             matrix[2] = self.size[0] / 2 - x
  856.             matrix[5] = self.size[1] / 2 - y
  857.             return self.transform((w, h), AFFINE, matrix)
  858.         
  859.         if resample not in (NEAREST, BILINEAR, BICUBIC):
  860.             raise ValueError('unknown resampling filter')
  861.         
  862.         self.load()
  863.         if self.mode in ('1', 'P'):
  864.             resample = NEAREST
  865.         
  866.         return self._new(self.im.rotate(angle, resample))
  867.  
  868.     
  869.     def save(self, fp, format = None, **params):
  870.         if isStringType(fp):
  871.             filename = fp
  872.         elif hasattr(fp, 'name') and isStringType(fp.name):
  873.             filename = fp.name
  874.         else:
  875.             filename = ''
  876.         self.load()
  877.         self.encoderinfo = params
  878.         self.encoderconfig = ()
  879.         preinit()
  880.         ext = string.lower(os.path.splitext(filename)[1])
  881.         if not format:
  882.             
  883.             try:
  884.                 format = EXTENSION[ext]
  885.             except KeyError:
  886.                 init()
  887.                 
  888.                 try:
  889.                     format = EXTENSION[ext]
  890.                 except KeyError:
  891.                     raise KeyError(ext)
  892.                 except:
  893.                     None<EXCEPTION MATCH>KeyError
  894.                 
  895.  
  896.                 None<EXCEPTION MATCH>KeyError
  897.             
  898.  
  899.         None<EXCEPTION MATCH>KeyError
  900.         
  901.         try:
  902.             save_handler = SAVE[string.upper(format)]
  903.         except KeyError:
  904.             init()
  905.             save_handler = SAVE[string.upper(format)]
  906.  
  907.         if isStringType(fp):
  908.             import __builtin__
  909.             fp = __builtin__.open(fp, 'wb')
  910.             close = 1
  911.         else:
  912.             close = 0
  913.         
  914.         try:
  915.             save_handler(self, fp, filename)
  916.         finally:
  917.             if close:
  918.                 fp.close()
  919.             
  920.  
  921.  
  922.     
  923.     def seek(self, frame):
  924.         if frame != 0:
  925.             raise EOFError
  926.         
  927.  
  928.     
  929.     def show(self, title = None, command = None):
  930.         _showxv(self, title, command)
  931.  
  932.     
  933.     def split(self):
  934.         ims = []
  935.         self.load()
  936.         for i in range(self.im.bands):
  937.             ims.append(self._new(self.im.getband(i)))
  938.         
  939.         return tuple(ims)
  940.  
  941.     
  942.     def tell(self):
  943.         return 0
  944.  
  945.     
  946.     def thumbnail(self, size, resample = NEAREST):
  947.         (x, y) = self.size
  948.         if x > size[0]:
  949.             y = max(y * size[0] / x, 1)
  950.             x = size[0]
  951.         
  952.         if y > size[1]:
  953.             x = max(x * size[1] / y, 1)
  954.             y = size[1]
  955.         
  956.         size = (x, y)
  957.         if size == self.size:
  958.             return None
  959.         
  960.         self.draft(None, size)
  961.         self.load()
  962.         
  963.         try:
  964.             im = self.resize(size, resample)
  965.         except ValueError:
  966.             if resample != ANTIALIAS:
  967.                 raise 
  968.             
  969.             im = self.resize(size, NEAREST)
  970.  
  971.         self.im = im.im
  972.         self.mode = im.mode
  973.         self.size = size
  974.         self.readonly = 0
  975.  
  976.     
  977.     def transform(self, size, method, data = None, resample = NEAREST, fill = 1):
  978.         import ImageTransform
  979.         if isinstance(method, ImageTransform.Transform):
  980.             (method, data) = method.getdata()
  981.         
  982.         if data is None:
  983.             raise ValueError('missing method data')
  984.         
  985.         im = new(self.mode, size, None)
  986.         if method == MESH:
  987.             for box, quad in data:
  988.                 im._Image__transformer(box, self, QUAD, quad, resample, fill)
  989.             
  990.         else:
  991.             im._Image__transformer((0, 0) + size, self, method, data, resample, fill)
  992.         return im
  993.  
  994.     
  995.     def __transformer(self, box, image, method, data, resample = NEAREST, fill = 1):
  996.         w = box[2] - box[0]
  997.         h = box[3] - box[1]
  998.         if method == AFFINE:
  999.             data = (data[2], data[0], data[1], data[5], data[3], data[4])
  1000.         elif method == EXTENT:
  1001.             (x0, y0, x1, y1) = data
  1002.             xs = float(x1 - x0) / w
  1003.             ys = float(y1 - y0) / h
  1004.             method = AFFINE
  1005.             data = (x0 + xs / 2, xs, 0, y0 + ys / 2, 0, ys)
  1006.         elif method == PERSPECTIVE:
  1007.             data = (data[2], data[0], data[1], data[5], data[3], data[4], data[6], data[7])
  1008.         elif method == QUAD:
  1009.             nw = data[0:2]
  1010.             sw = data[2:4]
  1011.             se = data[4:6]
  1012.             ne = data[6:8]
  1013.             (x0, y0) = nw
  1014.             As = 1 / w
  1015.             At = 1 / h
  1016.             data = (x0, (ne[0] - x0) * As, (sw[0] - x0) * At, ((se[0] - sw[0] - ne[0]) + x0) * As * At, y0, (ne[1] - y0) * As, (sw[1] - y0) * At, ((se[1] - sw[1] - ne[1]) + y0) * As * At)
  1017.         else:
  1018.             raise ValueError('unknown transformation method')
  1019.         if resample not in (NEAREST, BILINEAR, BICUBIC):
  1020.             raise ValueError('unknown resampling filter')
  1021.         
  1022.         image.load()
  1023.         self.load()
  1024.         if image.mode in ('1', 'P'):
  1025.             resample = NEAREST
  1026.         
  1027.         self.im.transform2(box, image.im, method, data, resample, fill)
  1028.  
  1029.     
  1030.     def transpose(self, method):
  1031.         self.load()
  1032.         im = self.im.transpose(method)
  1033.         return self._new(im)
  1034.  
  1035.  
  1036.  
  1037. class _ImageCrop(Image):
  1038.     
  1039.     def __init__(self, im, box):
  1040.         Image.__init__(self)
  1041.         (x0, y0, x1, y1) = box
  1042.         if x1 < x0:
  1043.             x1 = x0
  1044.         
  1045.         if y1 < y0:
  1046.             y1 = y0
  1047.         
  1048.         self.mode = im.mode
  1049.         self.size = (x1 - x0, y1 - y0)
  1050.         self._ImageCrop__crop = (x0, y0, x1, y1)
  1051.         self.im = im.im
  1052.  
  1053.     
  1054.     def load(self):
  1055.         if self._ImageCrop__crop:
  1056.             self.im = self.im.crop(self._ImageCrop__crop)
  1057.             self._ImageCrop__crop = None
  1058.         
  1059.  
  1060.  
  1061.  
  1062. def _wedge():
  1063.     return Image()._new(core.wedge('L'))
  1064.  
  1065.  
  1066. def new(mode, size, color = 0):
  1067.     if color is None:
  1068.         return Image()._new(core.new(mode, size))
  1069.     
  1070.     if isStringType(color):
  1071.         import ImageColor
  1072.         color = ImageColor.getcolor(color, mode)
  1073.     
  1074.     return Image()._new(core.fill(mode, size, color))
  1075.  
  1076.  
  1077. def fromstring(mode, size, data, decoder_name = 'raw', *args):
  1078.     if len(args) == 1 and isTupleType(args[0]):
  1079.         args = args[0]
  1080.     
  1081.     if decoder_name == 'raw' and args == ():
  1082.         args = mode
  1083.     
  1084.     im = new(mode, size)
  1085.     im.fromstring(data, decoder_name, args)
  1086.     return im
  1087.  
  1088.  
  1089. def frombuffer(mode, size, data, decoder_name = 'raw', *args):
  1090.     if len(args) == 1 and isTupleType(args[0]):
  1091.         args = args[0]
  1092.     
  1093.     if decoder_name == 'raw':
  1094.         if args == ():
  1095.             if warnings:
  1096.                 warnings.warn("the frombuffer defaults may change in a future release; for portability, change the call to read:\n  frombuffer(mode, size, data, 'raw', mode, 0, 1)", RuntimeWarning, stacklevel = 2)
  1097.             
  1098.             args = (mode, 0, -1)
  1099.         
  1100.         if args[0] in _MAPMODES:
  1101.             im = new(mode, (1, 1))
  1102.             im = im._new(core.map_buffer(data, size, decoder_name, None, 0, args))
  1103.             im.readonly = 1
  1104.             return im
  1105.         
  1106.     
  1107.     return apply(fromstring, (mode, size, data, decoder_name, args))
  1108.  
  1109.  
  1110. def fromarray(obj, mode = None):
  1111.     arr = obj.__array_interface__
  1112.     shape = arr['shape']
  1113.     ndim = len(shape)
  1114.     
  1115.     try:
  1116.         strides = arr['strides']
  1117.     except KeyError:
  1118.         strides = None
  1119.  
  1120.     if mode is None:
  1121.         typestr = arr['typestr']
  1122.         if not typestr[0] == '|' and typestr[0] == _ENDIAN or typestr[1:] not in ('u1', 'b1', 'i4', 'f4'):
  1123.             raise TypeError('cannot handle data-type')
  1124.         
  1125.         typestr = typestr[:2]
  1126.         if typestr == 'i4':
  1127.             mode = 'I'
  1128.         elif typestr == 'f4':
  1129.             mode = 'F'
  1130.         elif typestr == 'b1':
  1131.             mode = '1'
  1132.         elif ndim == 2:
  1133.             mode = 'L'
  1134.         elif ndim == 3:
  1135.             mode = 'RGB'
  1136.         elif ndim == 4:
  1137.             mode = 'RGBA'
  1138.         else:
  1139.             raise TypeError('Do not understand data.')
  1140.     
  1141.     ndmax = 4
  1142.     bad_dims = 0
  1143.     if mode in ('1', 'L', 'I', 'P', 'F'):
  1144.         ndmax = 2
  1145.     elif mode == 'RGB':
  1146.         ndmax = 3
  1147.     
  1148.     if ndim > ndmax:
  1149.         raise ValueError('Too many dimensions.')
  1150.     
  1151.     size = shape[:2][::-1]
  1152.     if strides is not None:
  1153.         obj = obj.tostring()
  1154.     
  1155.     return frombuffer(mode, size, obj, 'raw', mode, 0, 1)
  1156.  
  1157.  
  1158. def open(fp, mode = 'r'):
  1159.     if mode != 'r':
  1160.         raise ValueError('bad mode')
  1161.     
  1162.     if isStringType(fp):
  1163.         import __builtin__
  1164.         filename = fp
  1165.         fp = __builtin__.open(fp, 'rb')
  1166.     else:
  1167.         filename = ''
  1168.     prefix = fp.read(16)
  1169.     preinit()
  1170.     for i in ID:
  1171.         
  1172.         try:
  1173.             (factory, accept) = OPEN[i]
  1174.             if not accept or accept(prefix):
  1175.                 fp.seek(0)
  1176.                 return factory(fp, filename)
  1177.         continue
  1178.         except (SyntaxError, IndexError, TypeError):
  1179.             continue
  1180.         
  1181.  
  1182.     
  1183.     init()
  1184.     for i in ID:
  1185.         
  1186.         try:
  1187.             (factory, accept) = OPEN[i]
  1188.             if not accept or accept(prefix):
  1189.                 fp.seek(0)
  1190.                 return factory(fp, filename)
  1191.         continue
  1192.         except (SyntaxError, IndexError, TypeError):
  1193.             None<EXCEPTION MATCH>(SyntaxError, IndexError, TypeError)
  1194.             None<EXCEPTION MATCH>(SyntaxError, IndexError, TypeError)
  1195.             continue
  1196.         
  1197.  
  1198.     
  1199.     raise IOError('cannot identify image file')
  1200.  
  1201.  
  1202. def blend(im1, im2, alpha):
  1203.     im1.load()
  1204.     im2.load()
  1205.     return im1._new(core.blend(im1.im, im2.im, alpha))
  1206.  
  1207.  
  1208. def composite(image1, image2, mask):
  1209.     image = image2.copy()
  1210.     image.paste(image1, None, mask)
  1211.     return image
  1212.  
  1213.  
  1214. def eval(image, *args):
  1215.     return image.point(args[0])
  1216.  
  1217.  
  1218. def merge(mode, bands):
  1219.     if getmodebands(mode) != len(bands) or '*' in mode:
  1220.         raise ValueError('wrong number of bands')
  1221.     
  1222.     for im in bands[1:]:
  1223.         if im.mode != getmodetype(mode):
  1224.             raise ValueError('mode mismatch')
  1225.         
  1226.         if im.size != bands[0].size:
  1227.             raise ValueError('size mismatch')
  1228.             continue
  1229.     
  1230.     im = core.new(mode, bands[0].size)
  1231.     for i in range(getmodebands(mode)):
  1232.         bands[i].load()
  1233.         im.putband(bands[i].im, i)
  1234.     
  1235.     return bands[0]._new(im)
  1236.  
  1237.  
  1238. def register_open(id, factory, accept = None):
  1239.     id = string.upper(id)
  1240.     ID.append(id)
  1241.     OPEN[id] = (factory, accept)
  1242.  
  1243.  
  1244. def register_mime(id, mimetype):
  1245.     MIME[string.upper(id)] = mimetype
  1246.  
  1247.  
  1248. def register_save(id, driver):
  1249.     SAVE[string.upper(id)] = driver
  1250.  
  1251.  
  1252. def register_extension(id, extension):
  1253.     EXTENSION[string.lower(extension)] = string.upper(id)
  1254.  
  1255.  
  1256. def _showxv(image, title = None, command = None):
  1257.     if os.name == 'nt':
  1258.         format = 'BMP'
  1259.     elif sys.platform == 'darwin':
  1260.         format = 'JPEG'
  1261.         if not command:
  1262.             command = 'open -a /Applications/Preview.app'
  1263.         
  1264.     else:
  1265.         format = None
  1266.         if not command:
  1267.             command = 'xv'
  1268.             if title:
  1269.                 command = command + ' -name "%s"' % title
  1270.             
  1271.         
  1272.     if image.mode == 'I;16':
  1273.         base = 'L'
  1274.     else:
  1275.         base = getmodebase(image.mode)
  1276.     if base != image.mode and image.mode != '1':
  1277.         file = image.convert(base)._dump(format = format)
  1278.     else:
  1279.         file = image._dump(format = format)
  1280.     if os.name == 'nt':
  1281.         command = 'start /wait %s && del /f %s' % (file, file)
  1282.     elif sys.platform == 'darwin':
  1283.         command = '(%s %s; sleep 20; rm -f %s)&' % (command, file, file)
  1284.     else:
  1285.         command = '(%s %s; rm -f %s)&' % (command, file, file)
  1286.     os.system(command)
  1287.  
  1288.